package com.example;

import java.util.List;

import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.functions.Func1;

public class MyClass {
    public static void main(String[] arg0) {
        //Observable（可观察者，即被观察者），Observer（观察者），Subscribe（订阅），事件
        //Observable和Observer通过Subscribe实现订阅关系，Observable可以在需要发生事件的时候通知Observer
        //1.  Observer观察这，它决定事件触发的时候将有什么行为。

//        Observer<String> observer = new Observer<String>() {
//            @Override
//            public void onCompleted() {
//                System.out.println("完成");
//            }
//
//            @Override
//            public void onError(Throwable e) {
//                System.out.println(e.toString());
//            }
//
//            @Override
//            public void onNext(String s) {
//                System.out.println(s);
//            }
//        };


        //2.除了Subscriber接口之外，RxJava还内置了一个实现了Observer的抽象类
//        Subscriber<String> subscriber = new Subscriber<String>() {
//
//            @Override
//            public void onStart() {
//                super.onStart();
//
//            }
//
//            @Override
//            public void onCompleted() {
//
//            }
//
//            @Override
//            public void onError(Throwable e) {
//
//            }
//
//            @Override
//            public void onNext(String s) {
//
//            }
//        };


        //被观察者，决定什么时候触发事件，以及触发怎样的事件
        // just()方法，传人的参数依次发送
        //from(T())将传入的数组或者Iterable拆分成具体对象后，依次发送出来
        //Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
//            @Override
//            public void call(Subscriber<? super String> subscriber) {
//                subscriber.onNext("Hello");
//                subscriber.onNext("Hi");
//                subscriber.onNext("Hello");
//                subscriber.onCompleted();
//            }
//        });
//        observable.subscribe(observer);

//        Observable observable=Observable.just("111","222","333");
//        observable.subscribe(observer);


//        String[] words = {"hello", "Hi", "222"};
//        Observable observable = Observable.from(words);
//        observable.subscribe(observer);
//
//        Observable.just("images").map(new Func1<String, String>() {
//            @Override
//            public String call(String s) {
//                return s;
//            }
//        }).subscribe(new Action1<String>() {
//            @Override
//            public void call(String s) {
//                System.out.println(s);
//            }
//        });
//
//        //3.订阅
//        observable.subscribe(observer);
//
//        Action1<String> action1 = new Action1<String>() {
//            @Override
//            public void call(String s) {
//
//            }
//        };
//
//        Action0 action0=new Action0() {
//            @Override
//            public void call() {
//
//            }
//        };
//
//        observable.subscribe(action1);

        //Action0和Action1。Action0是RxJava的一个接口，它只有一个方法call()这个方法就是无参返回值
        String[] names = {"11", "22", "33", "44", "55", "66"};
        Observable.from(names).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println(s);
            }
        });


//        3.线程控制－－Scheduler
        //在RxJava的默认规则中，事件的发出和消费都是在同一个线程。
        //要实现后台处理，前台回调的异步机制
        //要实现异步，则需要用到RxJava的另一个概念Scheduler
        //内置Scheduler
        //Schedulers.immediate()
        //Schedulers.newThread()
        //Schedulers.io()（读写文件，读写数据库，网络信息交互等）
        //Schedulers.computation()

//        AndroidSchedulers.mainThread()

        //用subscribeOn（）和observeOn


        //4.变换
        //RxJava提供了对事件系列进行变换的支持，所谓变换，就是将事件系列中的对象或整个系列进行加工处理，转换成不同的事件或者事件系列


//        Observable.just("images/logo.png").map(new Func1<String, Bitmap>() {
//            @Override
//            public Bitmap call(String s) {
//                return null;
//            }
//        }).subscribe(new Action1<Bitmap>() {
//            @Override
//            public void call(Bitmap bitmap) {
//
//            }
//        });

        //Func1类和Action1类
        //这里出现了叫做Func1的类，他和Action1非常相识，
        //Func1有返回值

        //map()对事件的变换


        //flatMap()
        String[] students = {"11", "22", "33", "44"};
        Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        };

        Observable.from(students).map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return s;
            }
        }).subscribe(subscriber);


    }
}
